home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 3 / Cream of the Crop 3.iso / comm / wnos5src.zip / SERVER.C < prev    next >
Text File  |  1993-10-18  |  29KB  |  1,490 lines
  1. /* Server start/stop functions */
  2. /* Copyright 1991/2 Phil Karn, KA9Q */
  3.  
  4. #include <stdio.h>
  5. #include <ctype.h>
  6. #include "global.h"
  7. #include "config.h"
  8.  
  9. #ifdef SERVERS
  10. #include "socket.h"
  11. #include "session.h"
  12. #include "commands.h"
  13. #include "remote.h"
  14. #include "smtp.h"
  15. #include "tcp.h"            /* for kick() */
  16. #include "files.h"
  17. #include "dirutil.h"
  18. #include "devparam.h"
  19.  
  20. #include "bbs.h"
  21.  
  22. #ifdef DNS
  23. #include "domain.h"
  24. #endif
  25.  
  26. #ifdef LZW
  27. #include "lzw.h"
  28. #endif
  29.  
  30. #ifdef CONVERS
  31. #include "convers.h"
  32. #endif
  33.  
  34. #ifdef MAILBOX
  35. #include "mailbox.h"
  36. #endif
  37.  
  38. #ifdef POP
  39. #include "pop.h"
  40. #endif
  41.  
  42. #ifdef NNTP
  43. #include "nntp.h"
  44. #endif
  45.  
  46. #if(defined(MODEM) && defined(ASY))
  47. #include "asy.h"
  48. #include "n8250.h"
  49. #include "modem.h"
  50. #include "usock.h"
  51.  
  52. int tip0 __ARGS((int argc,char **argv,void *));
  53.  
  54. static struct tipcb *Tiplist = NULLTIP;
  55. #endif
  56.  
  57. #define DIFFTIME 2208988800L
  58.  
  59. static int SLoginwait = 0;
  60.  
  61. int Axi_sock = -1;
  62.  
  63. #ifdef CONVERS
  64. static int SConv = -1;
  65. #endif
  66. static int SDisc = -1;
  67. #ifdef DNS
  68. static int SDomain = -1;
  69. #endif
  70. static int SEcho = -1;
  71. static int SFinger = -1;
  72. static int SFtp = -1;
  73. #if (defined NETROM) && (defined MAILBOX)
  74. static int SNetrom = -1;
  75. #endif
  76. #ifdef NNTP
  77. static int SNntp = -1;
  78. #endif
  79. #ifdef POP
  80. static int SPop = -1;
  81. #endif
  82. static int SRem  = -1;
  83. static int SSmtp = -1;
  84. #ifdef MAILBOX
  85. static int STelnet = -1;
  86. #endif
  87. static int STime = -1;
  88. static int STtylink = -1;
  89. #if (defined CONVERS) && (defined LZW)
  90. static int SXConv = -1;
  91. #endif
  92.  
  93. #if (defined CONVERS) && (defined LINK)
  94. static struct proc *child = NULLPROC;
  95. #endif
  96.  
  97. #define CSTACKSIZE  1024    /* Convers server stacksize */
  98.  
  99. #ifdef NETROM
  100. #define MSTACKSIZE    4048    /* Mailbox stacksize */
  101. #else
  102. #define MSTACKSIZE    3072    /* Mailbox stacksize */
  103. #endif
  104.  
  105. #ifdef UDP
  106. char *Rempass = "";            /* Remote access password */
  107. #endif
  108.  
  109. static int near chkrpass (struct mbuf *bp);
  110. static void discserv (int s,void *unused,void *p);
  111. static void echoserv (int s,void *unused,void *p);
  112. static void fingerserv (int s,void *unused,void *p);
  113. static void timeserv (int s,void *unused,void *p);
  114.  
  115. static void near
  116. chpname(struct proc *pp,char *newname)
  117. {
  118.     sprintf(pp->name,"%.16s",newname);
  119. }
  120.  
  121. /* Wait for a signal that the RLSD modem status has changed */
  122. static int near
  123. get_rlsd_asy(int dev,int new_rlsd)
  124. {
  125.     struct asy *ap = &Asy[dev];
  126.  
  127.     if(ap->rlsd == 0) {
  128.         return -1;
  129.     }
  130.     for(;;) {
  131.         if(new_rlsd && (ap->msr & MSR_RLSD)) {
  132.             return 1;
  133.         }
  134.         if(!new_rlsd && !(ap->msr & MSR_RLSD)) {
  135.             return 0;
  136.         }
  137.         /* Wait for state change to requested value */
  138.         pause(2L);
  139.         pwait(&(ap->rlsd));
  140.     }
  141. }
  142.  
  143. /* ---------------------- Server start functions ----------------------- */
  144.  
  145. /* Start up TCP discard server */
  146. int
  147. dis1(int argc,char **argv,void *p)
  148. {
  149.     struct sockaddr_in lsocket;
  150.     int s;
  151.  
  152.     if(SDisc != -1) {
  153.         return 0;
  154.     }
  155.     psignal(Curproc,0);     /* Don't keep the parser waiting */
  156.     chpname(Curproc,"Discard listener");
  157.  
  158.     lsocket.sin_family = AF_INET;
  159.     lsocket.sin_addr.s_addr = INADDR_ANY;
  160.     lsocket.sin_port = (argc < 2) ? IPPORT_DISCARD : atoi(argv[1]);
  161.  
  162.     SDisc = socket(AF_INET,SOCK_STREAM,0);
  163.     bind(SDisc,(char *)&lsocket,SOCKSIZE);
  164.     listen(SDisc,1);
  165.  
  166.     for(;;){
  167.         if((s = accept(SDisc,NULLCHAR,0)) == -1) {
  168.             /* Service is shutting down */
  169.             break;
  170.         }
  171.         if(availmem()) {
  172.             /* Spawn a server */
  173.             newproc("Discard server",576,discserv,s,0,0,0);
  174.         } else {
  175.             shutdown(s,1);
  176.         }
  177.     }
  178.     return 0;
  179. }
  180.  
  181. /* Start up TCP echo server */
  182. int
  183. echo1(int argc,char **argv,void *p)
  184. {
  185.     struct sockaddr_in lsocket;
  186.     int s;
  187.  
  188.     if(SEcho != -1) {
  189.         return 0;
  190.     }
  191.     psignal(Curproc,0);     /* Don't keep the parser waiting */
  192.     chpname(Curproc,"Echo listener");
  193.  
  194.     lsocket.sin_family = AF_INET;
  195.     lsocket.sin_addr.s_addr = INADDR_ANY;
  196.     lsocket.sin_port = (argc < 2) ? IPPORT_ECHO : atoi(argv[1]);
  197.  
  198.     SEcho = socket(AF_INET,SOCK_STREAM,0);
  199.     bind(SEcho,(char *)&lsocket,SOCKSIZE);
  200.     listen(SEcho,1);
  201.  
  202.     for(;;){
  203.         if((s = accept(SEcho,NULLCHAR,0)) == -1) {
  204.             /* Service is shutting down */
  205.             break;
  206.         }
  207.         if(availmem()) {
  208.             /* Spawn a server */
  209.             newproc("Echo server",576,echoserv,s,0,0,0);
  210.         } else {
  211.             shutdown(s,1);
  212.         }
  213.     }
  214.     return 0;
  215. }
  216.  
  217. #if (defined MAILBOX) && (defined AX25)
  218. /* start up AX.25 Mailbox server */
  219. int
  220. ax25start(int argc,char **argv,void *p)
  221. {
  222.     int s;
  223.  
  224.     if(Axi_sock != -1) {
  225.         return 0;
  226.     }
  227.     psignal(Curproc,0);    /* Don't keep the parser waiting */
  228.     chpname(Curproc,"AX25 listener");
  229.  
  230.     Axi_sock = socket(AF_AX25,SOCK_STREAM,0);
  231.     /* bind() is done automatically */
  232.     listen(Axi_sock,1);
  233.  
  234.     for(;;){
  235.         if((s = accept(Axi_sock,NULLCHAR,0)) == -1) {
  236.             /* Service is shutting down */
  237.             break;
  238.         }
  239.         if(availmem()) {
  240.             /* Spawn a server then eat the line that triggered the
  241.              * connection and then start the mailbox
  242.              */
  243.             sockmode(s,SOCK_ASCII);            /* To make recvline work */
  244.             recvline(s,NULLCHAR,80);
  245.             newproc("Mbox (AX25)",MSTACKSIZE,mbx_incom,s,(void *)AX25TNC,0,0);
  246.         } else {
  247.             shutdown(s,1);
  248.         }
  249.     }
  250.     return 0;
  251. }
  252. #endif
  253.  
  254. #if (defined MAILBOX) && (defined NETROM)
  255. /* start up NETROM Mailbox server */
  256. int
  257. nr4start(int argc,char **argv,void *p)
  258. {
  259.     int s;
  260.  
  261.     if(SNetrom != -1) {
  262.         return 0;
  263.     }
  264.     psignal(Curproc,0);    /* Don't keep the parser waiting */
  265.     chpname(Curproc,"NETROM listener");
  266.  
  267.     SNetrom = socket(AF_NETROM,SOCK_SEQPACKET,0);
  268.     /* bind() is done automatically */
  269.     listen(SNetrom,1);
  270.  
  271.     for(;;){
  272.         if((s = accept(SNetrom,NULLCHAR,0)) == -1) {
  273.             /* Service is shutting down */
  274.             break;
  275.         }
  276.         if(availmem()) {
  277.             /* Spawn a server */
  278.             newproc("Mbox (NR)",MSTACKSIZE,mbx_incom,s,(void *)NRSESSION,0,0);
  279.         } else {
  280.             shutdown(s,1);
  281.         }
  282.     }
  283.     return 0;
  284. }
  285. #endif
  286.  
  287. #ifdef MAILBOX
  288. /* Start up Telnet server */
  289. int
  290. telnet1(int argc,char **argv,void *p)
  291. {
  292.     struct sockaddr_in lsocket;
  293.     int s;
  294.  
  295.     if(STelnet != -1) {
  296.         return 0;
  297.     }
  298.     psignal(Curproc,0);     /* Don't keep the parser waiting */
  299.     chpname(Curproc,"Telnet listener");
  300.  
  301.     lsocket.sin_family = AF_INET;
  302.     lsocket.sin_addr.s_addr = INADDR_ANY;
  303.     lsocket.sin_port = (argc < 2) ? IPPORT_TELNET : atoi(argv[1]);
  304.  
  305.     STelnet = socket(AF_INET,SOCK_STREAM,0);
  306.     bind(STelnet,(char *)&lsocket,SOCKSIZE);
  307.     listen(STelnet,1);
  308.  
  309.     for(;;){
  310.         if((s = accept(STelnet,NULLCHAR,0)) == -1) {
  311.             /* Service is shutting down */
  312.             break;
  313.         }
  314.         if(availmem()) {
  315.             /* Spawn a server */
  316.             newproc("Mbox (Telnet)",MSTACKSIZE,mbx_incom,s,(void *)TELNET,0,0);
  317.         } else {
  318.             shutdown(s,1);
  319.         }
  320.     }
  321.     return 0;
  322. }
  323. #endif
  324.  
  325. #ifdef UDP
  326. /* Start remote exit/reboot server */
  327. int
  328. rem1(int argc,char **argv,void *p)
  329. {
  330.     struct sockaddr_in lsocket, fsock;
  331.     int command;
  332.     struct mbuf *bp;
  333.     int32 addr = 0;
  334.  
  335.     if(SRem != -1) {
  336.         return 0;
  337.     }
  338.     psignal(Curproc,0);
  339.     chpname(Curproc,"Remote listener");
  340.  
  341.     lsocket.sin_family = AF_INET;
  342.     lsocket.sin_addr.s_addr = INADDR_ANY;
  343.     lsocket.sin_port = (argc < 2) ? IPPORT_REMOTE : atoi(argv[1]);
  344.  
  345.     SRem = socket(AF_INET,SOCK_DGRAM,0);
  346.     bind(SRem,(char *)&lsocket,SOCKSIZE);
  347.  
  348.     for(;;){
  349.         int i = SOCKSIZE;
  350.  
  351.         if(recv_mbuf(SRem,&bp,0,(char *)&fsock,&i) == -1) {
  352.             break;
  353.         }
  354.         command = PULLCHAR(&bp);
  355.         i = chkrpass(bp);
  356.  
  357.         switch(command){
  358.         case SYS_RESET:
  359.             log(SRem,9983,"REM  reset %s %s",
  360.                 psocket((struct sockaddr *)&fsock),i ? "" : "PASS FAIL");
  361.  
  362.             if(i) {
  363.                 void far (*foo) __ARGS((void));
  364.  
  365.                 /* FFFF:0000 is hardware reset vector */
  366.                 foo = MK_FP(0xffff,0);
  367.  
  368.                 (*foo)();
  369.             }
  370.             break;
  371.         case SYS_EXIT:
  372.             log(SRem,9983,"REM  exit %s %s",
  373.                 psocket((struct sockaddr *)&fsock),i ? "" : "PASS FAIL");
  374.  
  375.             if(i) {
  376.                 char *arg[3];
  377.                 arg[1] = "254";
  378.                 doexit(0,arg,0);
  379.             }
  380.             break;
  381.         case KICK_ME:
  382.             if(len_p(bp) >= sizeof(int32)) {
  383.                 addr = pull32(&bp);
  384.             } else {
  385.                 addr = fsock.sin_addr.s_addr;
  386.             }
  387.             kick(addr);
  388.             smtptick((void *)addr);
  389.             break;
  390.         }
  391.         free_p(bp);
  392.     }
  393.     return 0;
  394. }
  395. #endif
  396.  
  397. #ifdef CONVERS
  398. /* Start up convers server */
  399. int
  400. conv1(int argc,char **argv,void *p)
  401. {
  402.     struct sockaddr_in lsocket;
  403.     int s;
  404.  
  405.     if(SConv != -1) {
  406.         return 0;
  407.     }
  408.     psignal(Curproc,0);         /* Don't keep the parser waiting */
  409.     chpname(Curproc,"Convers listener");
  410.  
  411.     lsocket.sin_family = AF_INET;
  412.     lsocket.sin_addr.s_addr = INADDR_ANY;
  413.     lsocket.sin_port = (argc < 2) ? IPPORT_CONVERS : atoi(argv[1]);
  414.  
  415.     SConv = socket(AF_INET,SOCK_STREAM,0);
  416.     bind(SConv,(char *)&lsocket,SOCKSIZE);
  417.     listen(SConv,1);
  418.  
  419. #ifdef LINK
  420.     if(child == NULLPROC) {
  421.         child = newproc("cperm",1024,connect_Permlink,0,0,0,0);
  422.     }
  423. #endif
  424.  
  425.     for(;;){
  426.         if((s = accept(SConv,NULLCHAR,0)) == -1) {
  427.             /* Service is shutting down */
  428.             break;
  429.         }
  430.         if(availmem()) {
  431.             /* Spawn a server */
  432.             newproc("Convers server",CSTACKSIZE,conv_incom,s,0,0,0);
  433.         } else {
  434.             shutdown(s,1);
  435.         }
  436.     }
  437.     return 0;
  438. }
  439. #endif
  440.  
  441. #if (defined CONVERS) && (defined LZW)
  442. /* Start up xconvers server */
  443. int
  444. xconv1(int argc,char **argv,void *p)
  445. {
  446.     struct sockaddr_in lsocket;
  447.     int s;
  448.  
  449.     if(SXConv != -1) {
  450.         return 0;
  451.     }
  452.     psignal(Curproc,0);         /* Don't keep the parser waiting */
  453.     chpname(Curproc,"XConv listener");
  454.  
  455.     lsocket.sin_family = AF_INET;
  456.     lsocket.sin_addr.s_addr = INADDR_ANY;
  457.     lsocket.sin_port = (argc < 2) ? IPPORT_XCONVERS : atoi(argv[1]);
  458.  
  459.     SXConv = socket(AF_INET,SOCK_STREAM,0);
  460.     bind(SXConv,(char *)&lsocket,SOCKSIZE);
  461.     listen(SXConv,1);
  462.  
  463. #ifdef LINK
  464.     if(child == NULLPROC) {
  465.         child = newproc("cperm",1024,connect_Permlink,0,0,0,0);
  466.     }
  467. #endif
  468.  
  469.     for(;;){
  470.         if((s = accept(SXConv,NULLCHAR,0)) == -1) {
  471.             /* Service is shutting down */
  472.             break;
  473.         }
  474.         if(availmem()) {
  475.             /* Spawn a server */
  476.             newproc("XConvers server",CSTACKSIZE,conv_incom,s,(void *)1,0,0);
  477.         } else {
  478.             shutdown(s,1);
  479.         }
  480.     }
  481.     return 0;
  482. }
  483. #endif
  484.  
  485. #ifdef DNS
  486. /* start up Domain server */
  487. int
  488. dom1(int argc,char **argv,void *p)
  489. {
  490.     struct sockaddr_in lsocket, from;
  491.     struct mbuf *bp;
  492.  
  493.     if(SDomain != -1) {
  494.         return 0;
  495.     }
  496.     psignal(Curproc,0);
  497.     chpname(Curproc,"Domain listener");
  498.  
  499.     lsocket.sin_family = AF_INET;
  500.     lsocket.sin_addr.s_addr = INADDR_ANY;
  501.     lsocket.sin_port = (argc < 2) ? IPPORT_DOMAIN : atoi(argv[1]);
  502.  
  503.     SDomain = socket(AF_INET,SOCK_DGRAM,0);
  504.     bind(SDomain,(char *)&lsocket,SOCKSIZE);
  505.  
  506.     for(;;){
  507.         struct dhdr *dhdr;
  508.         int i = SOCKSIZE;
  509.  
  510.         if(recv_mbuf(SDomain,&bp,0,(char *)&from,&i) == -1) {
  511.             break;
  512.         }
  513.         dhdr = mxallocw(sizeof(struct dhdr));
  514.         ntohdomain(dhdr,&bp);
  515.  
  516.         if(dhdr->qr != RESPONSE) {
  517.             struct Server *dp = mxallocw(sizeof(struct Server));
  518.             dp->address = from.sin_addr.s_addr;
  519.             dp->protocol = from.sin_port;
  520.  
  521.             if(dhdr->opcode != ZONEINIT) {
  522.                 newproc("Domain query",1024,proc_query,SDomain,(void *)dp,(void *)dhdr,0);
  523.             }
  524.         }
  525.     }
  526.     return 0;
  527. }
  528. #endif
  529.  
  530. /* Start up finger service */
  531. int
  532. fin1(int argc,char **argv,void *p)
  533. {
  534.     struct sockaddr_in lsocket;
  535.     int s;
  536.  
  537.     if(SFinger != -1) {
  538.         return 0;
  539.     }
  540.     psignal(Curproc,0);    /* Don't keep the parser waiting */
  541.     chpname(Curproc,"Finger listener");
  542.  
  543.     lsocket.sin_family = AF_INET;
  544.     lsocket.sin_addr.s_addr = INADDR_ANY;
  545.     lsocket.sin_port = (argc < 2) ? IPPORT_FINGER : atoi(argv[1]);
  546.  
  547.     SFinger = socket(AF_INET,SOCK_STREAM,0);
  548.     bind(SFinger,(char *)&lsocket,SOCKSIZE);
  549.     listen(SFinger,1);
  550.  
  551.     for(;;){
  552.         if((s = accept(SFinger,NULLCHAR,0)) == -1) {
  553.             /* Service is shutting down */
  554.             break;
  555.         }
  556.         if(availmem()) {
  557.             /* Spawn a server */
  558.             newproc("Finger server",1280,fingerserv,s,0,0,0);
  559.         } else {
  560.             shutdown(s,1);
  561.         }
  562.     }
  563.     return 0;
  564. }
  565.  
  566. /* Start up FTP service */
  567. int
  568. ftp1(int argc,char **argv,void *p)
  569. {
  570.     struct sockaddr_in lsocket;
  571.     int s;
  572.  
  573.     if(SFtp != -1) {
  574.         return 0;
  575.     }
  576.     psignal(Curproc,0);    /* Don't keep the parser waiting */
  577.     chpname(Curproc,"FTP listener");
  578.  
  579.     lsocket.sin_family = AF_INET;
  580.     lsocket.sin_addr.s_addr = INADDR_ANY;
  581.     lsocket.sin_port = (argc < 2) ? IPPORT_FTP : atoi(argv[1]);
  582.  
  583.     SFtp = socket(AF_INET,SOCK_STREAM,0);
  584.     bind(SFtp,(char *)&lsocket,SOCKSIZE);
  585.     listen(SFtp,1);
  586.  
  587.     for(;;){
  588.         if((s = accept(SFtp,NULLCHAR,0)) == -1) {
  589.             /* Service is shutting down */
  590.             break;
  591.         }
  592.         if(availmem()) {
  593.             /* 421 Spawn a server */
  594.             newproc("FTP server",1536,ftpserv,s,0,0,0);
  595.         } else {
  596.             shutdown(s,1);
  597.         }
  598.     }
  599.     return 0;
  600. }
  601.  
  602. #ifdef NNTP
  603. /* Start up NNTP receiver service */
  604. int
  605. nntp1(int argc,char **argv,void *p)
  606. {
  607.     struct sockaddr_in lsocket;
  608.     int s;
  609.  
  610.     if(SNntp != -1) {
  611.         return 0;
  612.     }
  613.     psignal(Curproc,0);    /* Don't keep the parser waiting */
  614.     chpname(Curproc,"NNTP listener");
  615.  
  616.     lsocket.sin_family = AF_INET;
  617.     lsocket.sin_addr.s_addr = INADDR_ANY;
  618.     lsocket.sin_port = (argc < 2) ? IPPORT_NNTP : atoi(argv[1]);
  619.  
  620.     SNntp = socket(AF_INET,SOCK_STREAM,0);
  621.     bind(SNntp,(char *)&lsocket,SOCKSIZE);
  622.     listen(SNntp,1);
  623.  
  624.     for(;;){
  625.         if((s = accept(SNntp,NULLCHAR,0)) == -1) {
  626.             /* Service is shutting down */
  627.             break;
  628.         }
  629.         if(availmem()) {
  630.             /* 503 Spawn a server */
  631.             newproc("NNTP server",4048,nntpserv,s,0,0,0);
  632.         } else {
  633.             shutdown(s,1);
  634.         }
  635.     }
  636.     return 0;
  637. }
  638. #endif
  639.  
  640. #ifdef POP
  641. /* Start up POP receiver service */
  642. int
  643. pop1(int argc,char **argv,void *p)
  644. {
  645.     struct sockaddr_in lsocket;
  646.     int s;
  647.  
  648.     if(SPop != -1) {
  649.         return 0;
  650.     }
  651.     psignal(Curproc,0);        /* Don't keep the parser waiting */
  652.     chpname(Curproc,"POP listener");
  653.  
  654.     lsocket.sin_family = AF_INET;
  655.     lsocket.sin_addr.s_addr = INADDR_ANY;
  656.     lsocket.sin_port = (argc < 2) ? IPPORT_POP : atoi(argv[1]);
  657.  
  658.     SPop = socket(AF_INET,SOCK_STREAM,0);
  659.     bind(SPop,(char *)&lsocket,SOCKSIZE);
  660.     listen(SPop,1);
  661.  
  662.     for (;;) {
  663.         if((s = accept(SPop,NULLCHAR,0)) == -1) {
  664.             /* Service is shutting down */
  665.             break;
  666.         }
  667.         if(availmem()) {
  668.             /* Spawn a server */
  669.             newproc("POP server",1536,popserv,s,0,0,0);
  670.         } else {
  671.             shutdown(s,1);
  672.         }
  673.     }
  674.     return 0;
  675. }
  676. #endif
  677.  
  678. /* Start up SMTP receiver service */
  679. int
  680. smtp1(int argc,char **argv,void *p)
  681. {
  682.     struct sockaddr_in lsocket;
  683.     int s;
  684.  
  685.     if(SSmtp != -1) {
  686.         return 0;
  687.     }
  688.     psignal(Curproc,0);    /* Don't keep the parser waiting */
  689.     chpname(Curproc,"SMTP listener");
  690.  
  691.     lsocket.sin_family = AF_INET;
  692.     lsocket.sin_addr.s_addr = INADDR_ANY;
  693.     lsocket.sin_port = (argc < 2) ? IPPORT_SMTP : atoi(argv[1]);
  694.  
  695.     SSmtp = socket(AF_INET,SOCK_STREAM,0);
  696.     bind(SSmtp,(char *)&lsocket,SOCKSIZE);
  697.     listen(SSmtp,1);
  698.  
  699.     for(;;){
  700.         if((s = accept(SSmtp,NULLCHAR,0)) == -1) {
  701.             /* Service is shutting down */
  702.             break;
  703.         }
  704.         if(availmem()) {
  705.             /* 421 Spawn a server */
  706.             newproc("SMTP server",3072,smtpserv,s,0,0,0);
  707.         } else {
  708.             shutdown(s,1);
  709.         }
  710.     }
  711.     return 0;
  712. }
  713.  
  714. #if(defined(MODEM) && defined(ASY))
  715. /* Start mailbox on serial line */
  716. int
  717. tip1(int argc,char **argv,void *p)
  718. {
  719.     struct iface *ifp;
  720.     struct tipcb *tip;
  721.     struct mbuf *bp;
  722.     struct usock *up0, *up1;
  723.     char *buf[2];
  724.     int c, cmd, s[2];
  725.  
  726.     if((ifp = if_lookup(argv[1])) == NULLIF){
  727.         tprintf(Badif,argv[1]);
  728.         return 1;
  729.     }
  730.     if(ifp->dev >= ASY_MAX || Asy[ifp->dev].iface != ifp ) {
  731.         tprintf(Badasy,argv[1]);
  732.         return -1;
  733.     }
  734.     if(ifp->raw == bitbucket) {
  735.         tprintf(TActive,argv[1]);
  736.         return 1;
  737.     }
  738.     psignal(Curproc,0);    /* Don't keep the parser waiting */
  739.     sprintf(Curproc->name,"Tip listener");
  740.  
  741.     tip = (struct tipcb *)mxallocw(sizeof(struct tipcb));
  742.     tip->next = Tiplist;
  743.     Tiplist = tip;
  744.  
  745.     /* Save output handler and temporarily redirect output to null */
  746.     tip->rawsave = ifp->raw;
  747.     ifp->raw = bitbucket;
  748.     tip->iface = ifp;
  749.     tip->proc = Curproc;
  750.     tip->timer.func = tipidle;
  751.     tip->timer.arg = (void *)tip;
  752.  
  753.     buf[1] = ifp->name;
  754.  
  755.     /* Suspend packet input drivers */
  756.     suspend(ifp->proc);
  757.  
  758.     for(;;) {
  759.         /* Wait for DCD to be asserted */
  760.         get_rlsd_asy(ifp->dev,1);
  761.  
  762.         if((s[0] = socket(AF_LOCAL,SOCK_STREAM,0)) == -1) {
  763.             tputs(Nosocket);
  764.             return tip0(2,buf,p);
  765.         }
  766.         if((s[1] = socket(AF_LOCAL,SOCK_STREAM,0)) == -1) {
  767.             close_s(s[0]);
  768.             tputs(Nosocket);
  769.             return tip0(2,buf,p);
  770.         }
  771.         up0 = itop(s[0]);
  772.         seteol(s[0],"\n");
  773.  
  774.         up1 = itop(s[1]);
  775.         seteol(s[1],"\n");
  776.  
  777.         up1->cb.local->peer = up0;
  778.         up0->cb.local->peer = up1;
  779.  
  780.         tip->echo = WONT;
  781.         tip->s = s[0];
  782.  
  783.         newproc("MBox (Modem)",MSTACKSIZE,mbx_incom,s[1],(void *)TIP,0,0);
  784.  
  785.         set_timer(&tip->timer,Tiptimeout * 1000);
  786.         start_timer(&tip->timer);
  787. /*
  788.         setflush(tip->s,-1);
  789.         sockmode(tip->s,SOCK_ASCII);
  790. */
  791.         /* Now fork into two paths, one rx, one tx */
  792.         tip->in = newproc("MBox (Modem in)",256,tip_in,ifp->dev,(void *)TIP,0,0);
  793.  
  794.         while((c = recvchar(tip->s)) != -1) {
  795.             if(c == IAC) {    /* ignore most telnet options */
  796.                 if((cmd = recvchar(tip->s)) == -1) {
  797.                     break;
  798.                 }
  799.                 if(cmd > 250 && cmd < 255) {
  800.                     if((c = recvchar(tip->s)) == -1) {
  801.                         break;
  802.                     }
  803.                     switch(cmd){
  804.                     case WILL:
  805.                         if(c == TN_ECHO) {
  806.                             tip->echo = cmd;
  807.                             cmd = DO;
  808.                         } else {
  809.                             cmd = DONT;
  810.                         }
  811.                         break;
  812.                     case WONT:
  813.                         if(c == TN_ECHO) {
  814.                             tip->echo = cmd;
  815.                         }
  816.                         cmd = DONT;
  817.                         break;
  818.                     case DO:
  819.                     case DONT:
  820.                         cmd = WONT;
  821.                         break;
  822.                     }
  823.                     usprintf(tip->s,"%c%c%c",IAC,cmd,c);
  824.                     usflush(tip->s);
  825.                 }
  826.                 continue;
  827.             }
  828.             if(c == '\n') {
  829.                 bp = qdata("\r\n",2);
  830.             } else {
  831.                 bp = pushdown(NULLBUF,1);
  832.                 *bp->data = c;
  833.             }
  834.             asy_send(ifp->dev,bp);
  835.             ifp->lastsent = secclock();
  836.         }
  837.         close_s(tip->s);
  838.         killproc(tip->in);
  839.         tip->in = NULLPROC;
  840.  
  841.         pwait(itop(s[1])); /* let mailbox terminate, if necessary */
  842.  
  843.         stop_timer(&tip->timer);
  844.  
  845.         /* Tell line to go down */
  846.         ifp->ioctl(ifp,PARAM_DOWN,TRUE,0L);
  847.  
  848.         /* Wait for DCD to be dropped */
  849.         get_rlsd_asy(ifp->dev,0);
  850.     }
  851. }
  852. #endif
  853.  
  854. int
  855. ttyl1(int argc,char **argv,void *p)
  856. {
  857.     struct sockaddr_in lsocket;
  858.     int s;
  859.  
  860.     if(STtylink != -1) {
  861.         return 0;
  862.     }
  863.     psignal(Curproc,0);    /* Don't keep the parser waiting */
  864.     chpname(Curproc,"TTYlink listener");
  865.  
  866.     lsocket.sin_family = AF_INET;
  867.     lsocket.sin_addr.s_addr = INADDR_ANY;
  868.     lsocket.sin_port = (argc < 2) ? IPPORT_TTYLINK : atoi(argv[1]);
  869.  
  870.     STtylink = socket(AF_INET,SOCK_STREAM,0);
  871.     bind(STtylink,(char *)&lsocket,SOCKSIZE);
  872.     listen(STtylink,1);
  873.  
  874.     for(;;) {
  875.         if((s = accept(STtylink,NULLCHAR,0)) == -1) {
  876.             /* Service is shutting down */
  877.             break;
  878.         }
  879.         if(availmem()) {
  880.             /* Spawn a server */
  881.             newproc("Chat",1024,ttylhandle,s,(void *)TELNET,0,0);
  882.         } else {
  883.             shutdown(s,1);
  884.         }
  885.     }
  886.     return 0;
  887. }
  888.  
  889. /* Start up time server */
  890. int
  891. time1(int argc,char **argv,void *p)
  892. {
  893.     struct sockaddr_in lsocket;
  894.     int s;
  895.  
  896.     if(STime != -1){
  897.         return 0;
  898.     }
  899.     psignal(Curproc,0);                /* Don't keep the parser waiting */
  900.     chpname(Curproc,"Time listener");
  901.  
  902.     lsocket.sin_family = AF_INET;
  903.     lsocket.sin_addr.s_addr = INADDR_ANY;
  904.     lsocket.sin_port = IPPORT_TIME;
  905.  
  906.     STime = socket(AF_INET,SOCK_STREAM,0);
  907.     bind(STime,(char *)&lsocket,sizeof(lsocket));
  908.     listen(STime,1);
  909.  
  910.     for(;;) {
  911.         if((s = accept(STime,NULLCHAR,0)) == -1) {
  912.             /* Service is shutting down */
  913.             break;
  914.         }
  915.         if(availmem()) {
  916.             /* Spawn a server */
  917.             newproc("Time",512,timeserv,s,0,0,0);
  918.         } else {
  919.             shutdown(s,1);
  920.         }
  921.     }
  922.     return 0;
  923. }
  924.  
  925. /* ---------------------- Server stop functions ----------------------- */
  926.  
  927. /* Stop discard server */
  928. int
  929. dis0(int argc,char **argv,void *p)
  930. {
  931.     close_s(SDisc);
  932.     SDisc = -1;
  933.     return 0;
  934. }
  935.  
  936. /* stop echo server */
  937. int
  938. echo0(int argc,char **argv,void *p)
  939. {
  940.     close_s(SEcho);
  941.     SEcho = -1;
  942.     return 0;
  943. }
  944.  
  945. #if (defined MAILBOX) && (defined AX25)
  946. int
  947. ax25stop(int argc,char **argv,void *p)
  948. {
  949.     close_s(Axi_sock);
  950.     Axi_sock = -1;
  951.     return 0;
  952. }
  953. #endif
  954.  
  955. #if (defined MAILBOX) && (defined NETROM)
  956. int
  957. nr4stop(int argc,char **argv,void *p)
  958. {
  959.     close_s(SNetrom);
  960.     SNetrom = -1;
  961.     return 0;
  962. }
  963. #endif
  964.  
  965. #ifdef MAILBOX
  966. /* Stop telnet server */
  967. int
  968. telnet0(int argc,char **argv,void *p)
  969. {
  970.     close_s(STelnet);
  971.     STelnet = -1;
  972.     return 0;
  973. }
  974. #endif
  975.  
  976. #ifdef UDP
  977. int
  978. rem0(int argc,char **argv,void *p)
  979. {
  980.     close_s(SRem);
  981.     SRem = -1;
  982.     return 0;
  983. }
  984. #endif
  985.  
  986. /* Stop convers server */
  987. #ifdef CONVERS
  988. int
  989. conv0(int argc,char **argv,void *p)
  990. {
  991.     if(SConv != -1) {
  992. #ifdef LINK
  993. #ifdef LZW
  994.         if(SXConv == -1) {
  995.             if(Permlink) {
  996.                 killproc(child);
  997.             }
  998.             child = NULLPROC;
  999.             xfree(CHostname);
  1000.         }
  1001. #else
  1002.         if(Permlink) {
  1003.             killproc(child);
  1004.         }
  1005.         child = NULLPROC;
  1006.         xfree(CHostname);
  1007. #endif
  1008. #endif
  1009.         close_s(SConv);
  1010.         SConv = -1;
  1011.     }
  1012.     return 0;
  1013. }
  1014. #endif
  1015.  
  1016. #if (defined CONVERS) && (defined LZW)
  1017. /* Stop xconvers server */
  1018. int
  1019. xconv0(int argc,char **argv,void *p)
  1020. {
  1021.     if(SXConv != -1) {
  1022. #ifdef LINK
  1023.         if(SConv == -1) {
  1024.             if(Permlink) {
  1025.                 killproc(child);
  1026.             }
  1027.             child = NULLPROC;
  1028.             xfree(CHostname);
  1029.         }
  1030. #endif
  1031.         close_s(SXConv);
  1032.         SXConv = -1;
  1033.     }
  1034.     return 0;
  1035. }
  1036. #endif
  1037.  
  1038. #ifdef DNS
  1039. int
  1040. dom0(int argc,char **argv,void *p)
  1041. {
  1042.     close_s(SDomain);
  1043.     SDomain = -1;
  1044.     return 0;
  1045. }
  1046. #endif
  1047.  
  1048. int
  1049. fin0(int argc,char **argv,void *p)
  1050. {
  1051.     close_s(SFinger);
  1052.     SFinger = -1;
  1053.     return 0;
  1054. }
  1055.  
  1056. /* Shut down FTP server */
  1057. int
  1058. ftp0(int argc,char **argv,void *p)
  1059. {
  1060.     close_s(SFtp);
  1061.     SFtp = -1;
  1062.     return 0;
  1063. }
  1064.  
  1065. #ifdef NNTP
  1066. /* Shutdown NNTP service */
  1067. int
  1068. nntp0(int argc,char **argv,void *p)
  1069. {
  1070.     close_s(SNntp);
  1071.     SNntp = -1;
  1072.     return 0;
  1073. }
  1074. #endif
  1075.  
  1076. #ifdef POP
  1077. /* Shutdown POP service */
  1078. int
  1079. pop0(int argc,char **argv,void *p)
  1080. {
  1081.     close_s(SPop);
  1082.     SPop = -1;
  1083.     return 0;
  1084. }
  1085. #endif
  1086.  
  1087. /* Shutdown SMTP service */
  1088. int
  1089. smtp0(int argc,char **argv,void *p)
  1090. {
  1091.     close_s(SSmtp);
  1092.     SSmtp = -1;
  1093.     return 0;
  1094. }
  1095.  
  1096. #if(defined(MODEM) && defined(ASY))
  1097. int
  1098. tip0(int argc,char **argv,void *p)
  1099. {
  1100.     struct iface *ifp;
  1101.     struct tipcb *tip, *tiplast = NULLTIP;
  1102.     struct proc *proc;
  1103.  
  1104.     if((ifp = if_lookup(argv[1])) == NULLIF){
  1105.         tprintf(Badif,argv[1]);
  1106.         return 1;
  1107.     }
  1108.     for(tip = Tiplist; tip != NULLTIP; tiplast = tip, tip = tip->next) {
  1109.         if(tip->iface == ifp) {
  1110.             if(tiplast != NULLTIP) {
  1111.                 tiplast->next = tip->next;
  1112.             } else {
  1113.                 Tiplist = tip->next;
  1114.             }
  1115.             proc = tip->proc;
  1116.             close_s(tip->s);
  1117.             ifp->raw = tip->rawsave;
  1118.             resume(ifp->proc);
  1119.             stop_timer(&tip->timer);
  1120.             killproc(tip->in);
  1121.             xfree(tip);
  1122.             killproc(proc);
  1123.             return 0;
  1124.         }
  1125.     }
  1126.     return 0;
  1127. }
  1128. #endif
  1129.  
  1130. /* Shut down Ttylink server */
  1131. int
  1132. ttyl0(int argc,char **argv,void *p)
  1133. {
  1134.     close_s(STtylink);
  1135.     STtylink = -1;
  1136.     return 0;
  1137. }
  1138.  
  1139. /* Stop the time server */
  1140. int
  1141. time0(int argc,char **argv,void *p)
  1142. {
  1143.     close_s(STime);
  1144.     STime = -1;
  1145.     return 0;
  1146. }
  1147.  
  1148. /* -------------------- various server functions ------------------------ */
  1149.  
  1150. #ifdef UDP
  1151. /* Check remote password */
  1152. static int near
  1153. chkrpass(struct mbuf *bp)
  1154. {
  1155.     char lbuf[80];
  1156.  
  1157.     int16 len = len_p(bp);
  1158.  
  1159.     if(strlen(Rempass) != len) {
  1160.         return 0;
  1161.     }
  1162.     if(len > 79) {
  1163.         len = 79;
  1164.     }
  1165.     pullup(&bp,lbuf,len);
  1166.     return (strncmp(Rempass,lbuf,len) == 0);
  1167. }
  1168. #endif
  1169.  
  1170. static void
  1171. discserv(int s,void *unused,void *p)
  1172. {
  1173.     struct mbuf *bp;
  1174.  
  1175.     sockowner(s,Curproc);
  1176.     log(s,9983,"DISC open");
  1177.  
  1178.     while(recv_mbuf(s,&bp,0,NULLCHAR,0) > 0) {
  1179.         free_p(bp);
  1180.     }
  1181.     log(s,9983,"DISC close");
  1182.     close_s(s);
  1183. }
  1184.  
  1185. static void
  1186. echoserv(int s,void *unused,void *p)
  1187. {
  1188.     struct mbuf *bp;
  1189.  
  1190.     sockowner(s,Curproc);
  1191.     log(s,9983,"ECHO open");
  1192.  
  1193.     while(recv_mbuf(s,&bp,0,NULLCHAR,0) > 0) {
  1194.         send_mbuf(s,bp,0,NULLCHAR,0);
  1195.     }
  1196.     log(s,9983,"ECHO close");
  1197.     close_s(s);
  1198. }
  1199.  
  1200. static void
  1201. fingerserv(int s,void *unused,void *p)
  1202. {
  1203.     char user[LINELEN];
  1204.  
  1205.     sockowner(s,Curproc);
  1206.     sockmode(s,SOCK_ASCII);
  1207.     log(s,9983,"FING open");
  1208.  
  1209.     if(recvline(s,user,LINELEN) >= 0) {
  1210.         FILE *fp = NULLFILE;
  1211.  
  1212.         rip(user);
  1213.  
  1214.         if(strlen(user) == 0) {
  1215.             usprintf(s,"%snown users on this system\n",
  1216.                 ((fp = dir(Fdir,0)) == NULLFILE) ? "No k" : "K");
  1217.         } else {
  1218.             char *file = pathname(Fdir,user);
  1219.             char *cp   = pathname(Fdir,"");
  1220.  
  1221.             /* Check for attempted security violation (e.g., somebody
  1222.              * might be trying to finger "../ftpusers"!)
  1223.              */
  1224.             if(strncmp(file,cp,strlen(cp)) != 0) {
  1225.                 usputs(s,"Invalid user name\n");
  1226.             } else if((fp = Fopen(file,READ_TEXT,0,0)) == NULLFILE)
  1227.                 usprintf(s,"Unknown user '%s'\n",user);
  1228.             xfree(cp);
  1229.             xfree(file);
  1230.         }
  1231.         if(fp != NULLFILE) {
  1232.             sendfile(fp,s,ASCII_TYPE,0x80);
  1233.         }
  1234.     }
  1235.     log(s,9983,"FING close");
  1236.     close_s(s);
  1237. }
  1238.  
  1239. /*
  1240.  * Serve up the time to the connected client
  1241.  */
  1242. static void
  1243. timeserv(int s,void *unused,void *p)
  1244. {
  1245.     struct mbuf    *bp;
  1246.     char datetime[4];
  1247.  
  1248.     sockmode(s,SOCK_BINARY);
  1249.     sockowner(s,Curproc);
  1250.     log(s,9983,"TIME open");
  1251.  
  1252.     /*
  1253.      * Change 1970 start time to 1900 start time, and put
  1254.      * it in network order
  1255.      */
  1256.     put32(datetime,time((time_t *)0)+DIFFTIME);
  1257.  
  1258.     /* enqueue for transmission */
  1259.     bp = qdata(datetime,sizeof(int32));
  1260.  
  1261.     /* Send time data */
  1262.     send_mbuf(s,bp,0,NULLCHAR,0);
  1263.  
  1264.     log(s,9983,"TIME close");
  1265.     close_s(s);
  1266. }
  1267.  
  1268. static int near
  1269. get_perms(char *s)
  1270. {
  1271.     switch(tolower(*s)) {
  1272.     case 'b':                        /* bbs */
  1273.         return BBS;
  1274.     case 'm':                       /* mail */
  1275.         return MAIL;
  1276.     case 'n':                       /* news */
  1277.         return NEWS;
  1278.     case 'd':                       /* bbs & mail */
  1279.         return (BBS | MAIL);
  1280.     case 'r':                       /* bbs & news */
  1281.         return (BBS | NEWS);
  1282.     case 's':                       /* mail & news */
  1283.         return (MAIL | NEWS);
  1284.     case 't':                       /* bbs & mail & news */
  1285.         return (BBS | MAIL | NEWS);
  1286.     default:                        /* if someone prefer digits */
  1287.         return atoi(s);
  1288.     }
  1289. }
  1290.  
  1291. /* Subroutine for logging in the different server.
  1292.  * The buffer path is allocated here and must be freed from the calling
  1293.  * routine. A 'default' entry can be set in each file.
  1294.  * Return value: 0 if no permissions found, > 1 if permissions are given.
  1295.  */
  1296. int16
  1297. userlogin(int16 protocol,void *scb,char *ibuf)
  1298. {
  1299.   FILE *fp;
  1300.   char cp[LINELEN];
  1301.   int32 perms = 0;
  1302.  
  1303.   semwait(&SLoginwait,1);
  1304.  
  1305.   sprintf(cp,"%s/%s.rc",EtcRoot,tcp_port(protocol));
  1306.  
  1307.   if((fp = Fopen(cp,READ_TEXT,0,0)) != NULLFILE) {
  1308.     int def = FALSE;
  1309.     int32 def_perms = 0;
  1310.     char *def_arg2 = NULLCHAR, *def_arg3 = NULLCHAR;
  1311.     char arg1[40], arg2[40], arg3[40];
  1312.  
  1313.     for( ; ;) {
  1314.       memset(cp,0,LINELEN);
  1315.  
  1316.       fgets(cp,LINELEN,fp);
  1317.  
  1318.       /* Comment line */
  1319.       if(*cp == '#')
  1320.         continue;
  1321.  
  1322.       *arg1 = '\0';
  1323.       *arg2 = '\0';
  1324.       *arg3 = '\0';
  1325.       perms = 0;
  1326.  
  1327.       sscanf(cp,"%s %s %s %ld",arg1,arg2,arg3,&perms);
  1328.  
  1329.       if(stricmp(arg1,"default") == 0) {
  1330.         if(def_arg2) xfree(def_arg2);
  1331.         def_arg2 = strxdup(arg2);
  1332.         if(def_arg3) xfree(def_arg3);
  1333.         def_arg3 = strxdup(arg3);
  1334.         def_perms = perms;
  1335.         def = TRUE;
  1336.       } else {
  1337.         switch(protocol) {
  1338.           case IPPORT_FTP: {
  1339.             struct ftpserv *ftp = scb;
  1340.  
  1341.             if(stricmp(arg1,ftp->username) == 0) {
  1342.               if(strcmp(arg2,ibuf) == 0) {
  1343.                 ftp->path = strxdup(arg3);
  1344.                 ftp->perms = perms;
  1345.                 goto found;
  1346.               }
  1347.             }
  1348.             if(feof(fp)) {
  1349.               if(def == TRUE) {
  1350.                 ftp->path = strxdup(def_arg3);
  1351.                 ftp->perms = perms = def_perms;
  1352.               }
  1353.               goto found;
  1354.             }
  1355.             break;
  1356.           }
  1357.           case IPPORT_SMTP: {
  1358.             if(!stricmp(arg1,ibuf)) {
  1359. /*            if(strstr(ibuf,arg1)) {        */
  1360.               perms = get_perms(arg2);
  1361.               goto found;
  1362.             }
  1363.             if(feof(fp)) {
  1364.               if(def == TRUE) {
  1365.                 perms = get_perms(def_arg2);
  1366.               }
  1367.               goto found;
  1368.             }
  1369.             break;
  1370.           }
  1371. #ifdef POP
  1372.           case IPPORT_POP: {
  1373.             struct popserv *pop = scb;
  1374.  
  1375.             if(stricmp(arg1,pop->username) == 0) {
  1376.               if(strcmp(arg2,ibuf) == 0) {
  1377.                 perms = 1;
  1378.                 if(*arg3 == '\0') {
  1379.                   pop->path = mxallocw(MAXPATH);
  1380.                   sprintf(pop->path,"%s/%.8s.txt",Mailspool,pop->username);
  1381.                 } else {
  1382.                   pop->path = strxdup(arg3);
  1383.                 }
  1384.                 goto found;
  1385.               }
  1386.             }
  1387.             if(feof(fp)) {
  1388.               if(def == TRUE) {
  1389.                 perms = 1;
  1390.                 if(*def_arg3 != '\0') {
  1391.                   pop->def = TRUE;
  1392.                   pop->path = strxdup(def_arg3);
  1393.                 } else {
  1394.                     perms = 0;
  1395.                 }
  1396.               }
  1397.               goto found;
  1398.             }
  1399.             break;
  1400.           }
  1401. #endif
  1402. #ifdef MAILBOX
  1403.           case IPPORT_TELNET: {
  1404.             struct mbx *m = scb;
  1405.  
  1406.             if(stricmp(arg1,m->name) == 0) {
  1407.               m->path = strxdup(arg3);
  1408.               m->perms = perms;
  1409.  
  1410.               if(m->family == AF_AX25
  1411.                || m->family == AF_NETROM) {
  1412.                 ;
  1413.               } else {
  1414.                 if(strcmp(arg2,ibuf)) {
  1415.                   m->perms = perms = 0;
  1416.                 }
  1417.               }
  1418.               goto found;
  1419.             }
  1420.             if(feof(fp)) {
  1421.               if(def == TRUE) {
  1422.                 m->path = strxdup(def_arg3);
  1423.                 m->perms = perms = def_perms;
  1424.               }
  1425.               goto found;
  1426.             }
  1427.             break;
  1428.           }
  1429. /* new mailbox */
  1430.           case 9980: {
  1431.             struct user *user = scb;
  1432.  
  1433.             if(stricmp(arg1,ibuf) == 0) {
  1434.               perms = 1;
  1435.               if(user) {
  1436.                   strcpy(user->line,arg2);
  1437.               }
  1438.               goto found;
  1439.             }
  1440.             if(feof(fp)) {
  1441.               goto found;
  1442.             }
  1443.             break;
  1444.           }
  1445. #else
  1446.           case IPPORT_TELNET:
  1447. #endif
  1448.           case IPPORT_TTYLINK:
  1449.           case IPPORT_ECHO:
  1450.           case IPPORT_DISCARD:
  1451.           case IPPORT_FINGER:
  1452. #ifdef NNTP
  1453.           case IPPORT_NNTP:
  1454. #endif
  1455. #ifdef CONVERS
  1456.           case IPPORT_CONVERS:
  1457. #ifdef LZW
  1458.           case IPPORT_XCONVERS:
  1459. #endif
  1460. #endif
  1461. #ifdef DNS
  1462.           case IPPORT_DOMAIN:
  1463. #endif
  1464. #ifdef UDP
  1465.           case IPPORT_REMOTE:
  1466. #endif
  1467.           {
  1468.             perms = 1;
  1469.             goto found;
  1470.           }
  1471.         }
  1472.       if(feof(fp))
  1473.         goto found;
  1474.       }
  1475.     }
  1476. found:
  1477.     Fclose(fp);
  1478.  
  1479.     if(def_arg2) xfree(def_arg2);
  1480.     if(def_arg3) xfree(def_arg3);
  1481.   }
  1482.   semrel(&SLoginwait);
  1483.  
  1484.   /* Finally return the permission bits */
  1485.   return perms;
  1486. }
  1487.  
  1488.  
  1489. #endif /* SERVERS */
  1490.